The present disclosure relates to software containers, and more specifically, to managing initialization of software containers that are associated with dependent software containers.
Generally, software containers are isolated user-space instances that wrap software in a complete filesystem. A software container includes components that are required to run the software, such as code, a runtime environment, system tools, system libraries, and so on. Doing so ensures that the software will always run in an identical manner regardless of the execution environment. When executed, the software container maintains its own CPU, memory, I/O, and network resources and shares the kernel of the host operating system. Software containers are fairly lightweight (e.g., compared to virtual machines which often require duplicate instances of the operating system as well as redundant boot volumes), so multiple software containers can be executed on the same hardware.
Software containers run as a distinct process. Therefore, a given application architecture that executes multiple processes typically requires a software container for each distinct process. For example, a software container may correspond to a web server application for a given application architecture, while another software container may correspond to a database application for that application architecture. Further, some processes in the application architecture may depend on other processes. For instance, a software container that corresponds to a member service may need to communicate with a controller service that is executed as part of another software container.
A container management application may coordinate the execution of software containers to ensure that the application runs reliably. However, one concern is efficiently starting software containers that depend on another software container to be fully initialized. For example, if a given software container is not yet fully initialized, then software containers that depend on that software container to be running may fail to initialize. Consequently, after failure, the container management application may repeatedly attempt to initialize the dependent software containers. Such an approach may result in wasted resources.